home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / progtool / modula2 / hk_lib / def_mod / chars.def < prev    next >
Encoding:
Modula Definition  |  1994-09-22  |  12.8 KB  |  210 lines
  1. DEFINITION MODULE  Chars;
  2.  
  3. (*****************************************************************************)
  4. (* In diesem Modul sammelt sich alles, was mit Einzelzeichen zu tun hat, d.h.*)
  5. (* Definitionen von Konstanten - Control-Codes, Umlaute - ,Tests auf Zugehoe-*)
  6. (* rigkeit eines Zeichens zu einer bestimmten Klasse und die Umwandlung von  *)
  7. (* Zeichen einer Klasse in Zeichen einer anderen Klasse.                     *)
  8. (*                                                                           *)
  9. (* Thema Umlaute:                                                            *)
  10. (* --------------------------------------------------------------------------*)
  11. (* Falls mit dem Atari-Zeichensatz im Rechner und dem IBM-Zeichensatz auf dem*)
  12. (* Drucker gearbeitet werden soll, bietet sich an, statt des 'SZ' das grie-  *)
  13. (* chische Beta zu benutzen ( bei Atari und IBM gleich, andere Umlaute sind  *)
  14. (* bei beiden gleich ). Dazu muessen nur die Konstanten "Beta" und "SZ ausge-*)
  15. (* tauscht, und das Modul neu uebersetzt werden - es sind keine Aenderungen  *)
  16. (* an den Prozeduren noetig. ( Hinweise fuer Assemblerversionen im IMPLEMEN- *)
  17. (* TATION MODULE beachten ):                                                 *)
  18. (*                                                                           *)
  19. (* Das Paragraph-Zeichen hat keine Entsprechung im erweiterten IBM-Zeichen-  *)
  20. (* satz. Um es daher auf Papier zu kriegen, muss der nationale ( deutsche )  *)
  21. (* ASCII-Zeichensatz des Druckers eingeschaltet werden. Falls das Paragraph- *)
  22. (* Zeichen oefter benutzt wird, bietet es sich an, saemtliche deutsche Son-  *)
  23. (* derzeichen durch die Codes des deutschen ASCII-Zeichensatzes zu repraesen-*)
  24. (* tieren. Hierfuer sind die Prozeduren mit dem 'ASCII' im Namen gedacht -   *)
  25. (* sie verwenden fuer die deutschen Sonderzeichen die Codes des deutschen    *)
  26. (* ASCII-Sonderzeichensatzes. Auf dem Bildschirm werden die so codierten     *)
  27. (* Zeichen dann allerdings als Klammern, senkrechte Striche und Klammeraffe  *)
  28. (* ausgegeben.                                                               *)
  29. (*                                                                           *)
  30. (* Da der Rechner natuerlich nicht feststellen kann, wie ein bestimmter Code *)
  31. (* gerade interpretiert wird, d.h. ob der Atari-Code fuer die Sonderzeichen  *)
  32. (* benutzt wird oder der ASCII-Code, muss der Benutzer sich im klaren sein,  *)
  33. (* welchen Zeichencode er verwendet; andernfalls kann es manche Ueberra-     *)
  34. (* schung geben.                                                             *)
  35. (*                                                                           *)
  36. (* Je nach Anwendungsfall kommt man mit einer Sorte von Funktionen aus, oder *)
  37. (* man benutzt die eine fuer die Bildschirmdarstellung, die andere fuer den  *)
  38. (* Ausdruck. In die jeweils andere Darstellung kann man mit den entsprechen- *)
  39. (* den Konvertierroutinen gelangen.                                          *)
  40. (*                                                                           *)
  41. (* Man sollte sich bei allem was den Zeichensatz des Rechners betrifft der   *)
  42. (* Routinen in diesem Modul bedienen, um rechnerunabhaengig zu bleiben.      *)
  43. (*___________________________________________________________________________*)
  44. (*    12-Feb-90 , Holger Kleinschmidt                                        *)
  45. (*****************************************************************************)
  46.  
  47.  
  48.  
  49. TYPE
  50.        CharClassTest = PROCEDURE ((* EIN/ -- *) CHAR ): BOOLEAN;
  51.  
  52.        CharConvert   = PROCEDURE ((* EIN/ -- *) CHAR ): CHAR;
  53.  
  54.        (* Durch diese Prozedurtypen koennen beliebige der folgenden
  55.         * Funktionen, an andere Prozeduren als Parameter uebergeben
  56.         * werden. Dies dient z.B. dazu, Strings auf jeweils unter-
  57.         * schiedliche Weise mit derselben String-Prozedur zu bearbeiten.
  58.         * Es koennen natuerlich auch eigene Prozeduren mit dieser
  59.         * Funktionalitaet verwendet werden.
  60.         *)
  61.  
  62. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  63.  
  64.  
  65. PROCEDURE  IsASCII           ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  66. PROCEDURE  IsSpace           ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  67. PROCEDURE  IsControl         ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  68. PROCEDURE  IsSmallLetter     ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  69. PROCEDURE  IsBigLetter       ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  70. PROCEDURE  IsSmallUmlaut     ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  71. PROCEDURE  IsSmallASCIIUmlaut((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  72. PROCEDURE  IsBigUmlaut       ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  73. PROCEDURE  IsBigASCIIUmlaut  ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  74. PROCEDURE  IsBinDigit        ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  75. PROCEDURE  IsOctDigit        ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  76. PROCEDURE  IsDigit           ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  77. PROCEDURE  IsHexDigit        ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  78. PROCEDURE  IsPrintable       ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  79. PROCEDURE  IsGraphic         ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  80. PROCEDURE  IsLetter          ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  81. PROCEDURE  IsAlphanumeric    ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  82. PROCEDURE  IsDelimiter       ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  83. PROCEDURE  IsPunctuation     ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  84. PROCEDURE  IsUmlaut          ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  85. PROCEDURE  IsASCIIUmlaut     ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  86. PROCEDURE  IsSmallGerman     ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  87. PROCEDURE  IsSmallASCIIGerman((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  88. PROCEDURE  IsBigGerman       ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  89. PROCEDURE  IsBigASCIIGerman  ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  90. PROCEDURE  IsGerman          ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  91. PROCEDURE  IsASCIIGerman     ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
  92.  
  93. (*--------------------------------------------------------------------------
  94.  | Die Funktionen pruefen , ob <zeichen> zu der Klasse von Zeichen gehoert, |
  95.  | die durch die jeweiligen Funktionsnamen bezeichnet werden, dabei gelten  |
  96.  | folgende Gleichungen:                                                    |
  97.  |                                                                          |
  98.  |  IsASCII(z)            = 0 <= z <= 7FH                                   |
  99.  |  IsSpace(z)            = z IN { HT, VT, LF, FF, CR, ' ' }                |
  100.  |  IsControl(z)          = ( z = DEL )  OR  ( z < ' ' )                    |
  101.  |  IsSmallLetter(z)      = z IN {'a'..'z'}                                 |
  102.  |  IsBigLetter(z)        = z IN {'A'..'Z'}                                 |
  103.  |  IsSmallUmlaut(z)      = z IN { kleinesAE, kleinesOE, kleinesUE }        |
  104.  |  IsSmallASCIIUmlaut(z) = z IN { kleinesASCIIae, kleinesASCIIoe,          |
  105.  |                                 kleinesASCIIue                  }        |
  106.  |  IsBigUmlaut(z)        = z IN { grossesAE, grossesOE, grossesUE }        |
  107.  |  IsBigASCIIUmlaut(z)   = z IN { grossesASCIIae, grossesASCIIoe,          |
  108.  |                                 grossesASCIIue                  }        |
  109.  |  IsBinDigit(z)         = z IN {'0'..'1'}                                 |
  110.  |  IsOctDigit            = IsBinDigit(z)     OR  z IN {'2'..'7'}           |
  111.  |  IsDigit(z)            = IsOctDigit(z)     OR  z IN {'8', '9'}           |
  112.  |  IsHexDigit(z)         = IsDigit(z)        OR  z IN {'a'..'f', 'A'..'F'} |
  113.  |  IsPrintable(z)        = ~IsControl(z)                                   |
  114.  |  IsGraphic(z)          = ~IsControl(z)      & ( z # ' ' )                |
  115.  |  IsLetter(z)           = IsSmallLetter(z)  OR  IsBigLetter(z)            |
  116.  |  IsAlphanumeric(z)     = IsLetter(z)       OR  IsDigit(z)                |
  117.  |  IsDelimiter(z)        = IsASCII(z)         &  ~IsAlphanumeric(z)        |
  118.  |  IsPunctuation(z)      = IsASCII(z)         &  IsGraphic(z)              |
  119.  |                                             &  ~IsAlphanumeric(z)        |
  120.  |  IsUmlaut(z)           = IsBigUmlaut(z)    OR  IsSmallUmlaut(z)          |
  121.  |  IsASCIIUmlaut(z)      = IsBigASCIIUmlaut(z) OR IsSmallASCIIUmlaut(z)    |
  122.  |  IsSmallGerman(z)      = IsSmallLetter(z)  OR  IsSmallUmlaut(z)          |
  123.  |  IsSmallASCIIGerman(z) = IsSmallLetter(z)  OR  IsSmallASCIIUmlaut(z)     |
  124.  |  IsBigGerman(z)        = IsBigLetter(z)    OR  IsBigUmlaut(z)            |
  125.  |  IsBigASCIIGerman(z)   = IsBigLetter(z)    OR  IsBigASCIIUmlaut(z)       |
  126.  |  IsGerman(z)           = IsLetter(z)       OR  IsUmlaut(z)               |
  127.  |  IsASCIIGerman(z)      = IsLetter(z)       OR  IsASCIIUmlaut(z)          |
  128.   --------------------------------------------------------------------------*)
  129.  
  130.  
  131. PROCEDURE  IsOneOfSet ((* EIN/ -- *)  zeichen : CHAR;
  132.                        (* EIN/ -- *)  charSet : ARRAY OF CHAR ): BOOLEAN;
  133.  
  134. (*--------------------------------------------------------------------------
  135.  | Die Funktion prueft, ob <zeichen> eines der Zeichen ist, die in dem      |
  136.  | String <charSet> vorkommen.                                              |
  137.   --------------------------------------------------------------------------*)
  138.  
  139.  
  140.  
  141. PROCEDURE  ToAtariGerman ((* EIN/ -- *) zeichen : CHAR ): CHAR;
  142.  
  143. PROCEDURE  ToASCIIGerman ((* EIN/ -- *) zeichen : CHAR ): CHAR;
  144.  
  145. (*--------------------------------------------------------------------------
  146.  | Die Prozeduren dienen dazu, fuer die deutschen Sonderzeichen die Codes   |
  147.  | des einen Zeichensatzes in die des anderen umzurechnen. Ist <zeichen>    |
  148.  | kein deutsches Sonderzeichen ( nach der Interpretation des jeweils ANDE- |
  149.  | REN Zeichensatzes ! ), wird es unveraendert zurueckgeliefert.            |
  150.  | Deutsche Sonderzeichen sind die Umlaute, das sz und der Paragraph.       |
  151.   --------------------------------------------------------------------------*)
  152.  
  153.  
  154.  
  155. PROCEDURE  LowerCase            ((* EIN/ -- *) zeichen : CHAR ): CHAR;
  156.  
  157. PROCEDURE  LowerCaseGerman      ((* EIN/ -- *) zeichen : CHAR ): CHAR;
  158.  
  159. PROCEDURE  LowerCaseASCIIGerman ((* EIN/ -- *) zeichen : CHAR ): CHAR;
  160.  
  161. (*--------------------------------------------------------------------------
  162.  | Wenn <zeichen> ein Grossbuchstabe bzw. grosser Umlaut ist, wird der ent- |
  163.  | sprechende Kleinbuchstabe bzw. kleine Umlaut  zurueckgeliefert, sonst    |
  164.  | <zeichen> unveraendert.                                                  |
  165.  | 'LowerCaseGerman' ist fuer die Benutzung des Atari/IBM-Zeichensatzes bei |
  166.  | den Umlauten gedacht, 'LowerCaseASCIIGerman' fuer die Benutzung des      |
  167.  | deutschen ASCII-Sondercodes.                                             |
  168.   --------------------------------------------------------------------------*)
  169.  
  170.  
  171. PROCEDURE  CAPGerman      ((* EIN/ -- *) zeichen : CHAR ): CHAR;
  172.  
  173. PROCEDURE  CAPGermanASCII ((* EIN/ -- *) zeichen : CHAR ): CHAR;
  174.  
  175. (*--------------------------------------------------------------------------
  176.  | Falls <zeichen> ein Kleinbuchstabe oder ein kleiner Umlaut ist, wird der |
  177.  | entsprechende Grossbuchstabe bzw. der grosse Umlaut geliefert, sonst das |
  178.  | unveraenderte <zeichen>.                                                 |
  179.  | 'CAPGerman' muss verwendet werden, falls der Atari/IBM-Code fuer die Um- |
  180.  | laute benutzt wird, 'CAPGermanASCII' falls der deutsche ASCII-Sondercode |
  181.  | benutzt wird.                                                            |
  182.   --------------------------------------------------------------------------*)
  183.  
  184.  
  185. PROCEDURE  DigitToCard ((* EIN/ -- *) digit : CHAR ): CARDINAL;
  186.  
  187. PROCEDURE  CardToDigit ((* EIN/ -- *) card : CARDINAL ): CHAR;
  188.  
  189. (*--------------------------------------------------------------------------
  190.  | Umwandlung einer Ziffer in den entsprechenden positiven Zahlenwert, bzw. |
  191.  | umgekehrt.                                                               |
  192.  |  - Es wird nicht ueberprueft, ob bei 'CardToDigit' <card> eine Zahl      |
  193.  |    zwischen Null und neun ist, oder bei 'DigitToCard' <digit> eine       |
  194.  |    Ziffer zwischen '0' und '9'. Also darauf achten:                      |
  195.  |           '0' <= digit <= '9'     und     0 <= card <= 9                 |
  196.   --------------------------------------------------------------------------*)
  197.  
  198. PROCEDURE  HexDigitToCard ((* EIN/ -- *) hexdigit : CHAR ): CARDINAL;
  199.  
  200. PROCEDURE  CardToHexDigit ((* EIN/ -- *) hexvalue : CARDINAL ): CHAR;
  201.  
  202. (*--------------------------------------------------------------------------
  203.  | wie oben,                                                                |
  204.  |  "CardToHexDigit" : ( 0..15 )                    -> ('0'..'9','A'..'F')  |
  205.  |  "HexDigitToCard" : ('0'..'9','A'..'F','a'..'f') -> ( 0..15 )            |
  206.   --------------------------------------------------------------------------*)
  207.  
  208.  
  209. END  Chars.
  210.